#![feature(split_array)]
#[allow(unused,unused_mut)]
pub fn test_array() {
    test_def_and_access();
    test_fn_each();
    test_fn_map();
    test_split();
}

fn test_def_and_access() {
    //1.0 定义数组
    //最常见的是列出数组的类型和长度，然后初始化每个元素
    let arr1: [i32; 5] = [1, 2, 3, 4, 5];
    //或者使用初始化表达式[T;N] ,要求T是常量或者是实现了Copy特质的数据类型
    const FOOD: usize = 5; // 常量
    let arr2 = [FOOD; 5]; // 所有元素都是0的数组
    let arr3 = [0; 5]; // 所有元素都是0的数组
    println!("{:?}", arr1);
    println!("{:?}", arr2);
    println!("{:?}", arr3);

    //2.0 访问数组中的元素
    //数组的访问方式有多种，比如：通过索引访问、通过迭代器遍历等。

    //2.1 通过索引访问：

    let first_element = arr1[0];
    println!("第一个元素是 {}", first_element);
    //2.2 通过迭代器遍历：
    //也可以通过迭代器遍历数组中的元素：
    //`for element in &arr1` 是语法糖，会调用`arr1.into_iter()`返回不可变引用迭代器
    for element in &arr1 {
        println!("{}", element);
    }

    //2.3 通过切片访问：
    //还可以通过切片访问数组中的一部分元素：
    let slice = &arr1[0..3]; // 获取前三个元素的切片
    println!("{:?}", slice);

    //2.4 通过迭代器
    //`arr1.iter()` 显式调用，也返回不可变引用迭代器
    //两种方式功能相同，但`&arr1`更简洁，是推荐用法
    for element in arr1.iter() {
        println!("{}", element);
    }
}

/**
 * 测试函数each_mut()的使用  each_mut(&mut self) -> [&mut T; N]
 * 还有一个each_ref()函数，  each_ref(&self) -> [&T; N]
 * 不能说这两个方法没有什么用，在某些情况下还是有用的。比如在你想遍历数组但不希望修改其内容时，
 * 可以使用each_ref()方法返回一个不可变引用迭代器。
 * 而在你需要对数组中的元素进行修改时，则可以使用each_mut()方法返回一个可变引用迭代器。
 */
fn test_fn_each() {
    let mut girls = [
        "black-haired".to_string(),
        "blonde".to_string(),
        "brown-haired".to_string(),
    ];
    girls[0] = "lml".to_string();
    println!("{:?}", girls);
    for girl in girls.iter_mut() {
        girl.push_str(" 中国");
    }
    println!("{:?}", girls);

    for girl in girls.each_mut().iter_mut() {
        girl.push_str(" 中国");
    }
    println!("{:?}", girls);
}

/**
 * 这是一个有意思的函数
 * pub fn map<F, U>(self, f: F) -> [U; N] where F: FnMut(T) -> U,
 * 利用一个实现了FnMut特质（即实现了调用自身的方法）的函数f，将数组中的每个元素都转换成了U类型的新数组。
 *
 * 关于map的重要说明：
 * 1. map是惰性的，除非消费迭代器(如collect/for_each)，否则不会执行
 * 2. iter_mut().map()会返回新值，但不会修改原数组
 * 3. 要修改原数组，应该使用for_each或直接赋值
 */
#[allow(unused,unused_mut)]
fn test_fn_map() {
    let mut scores = [10, 20, 30];
    let f = |x: i32| x * 2;

    // 示例1：map创建新数组
    let new_scores = scores.map(f);
    println!("map创建的新数组: {:?}", new_scores);
    println!("原数组未被修改: {:?}", scores);

    // 示例2：使用Iterator::map，可以创建一个可变的迭代器，但不直接修改原数组
    //Iterator::map 返回一个Map(std::iter::Map)
    let f1=|x: &i32| {2*x};
    let mut bb = scores.iter().map(f1);  //|x:&i32| *x*2
    for x in bb {
        println!("{}", x);
    }
    println!("iter_mut().map()后数组未变: {:?}", scores);

    // 示例3：正确修改数组的方法
    // 方法1：使用for_each消费迭代器
    scores.iter_mut().for_each(|x| *x *= 2);
    println!("使用for_each后: {:?}", scores);

    let a = [1, 2, 3];
    let mut iter = a.iter().map(|x| 2 * x);
    println!("{:?}", iter.next()); // 2

    println!("{:?}", a); // 4
}

/**
 * 测试切割数组
 */
fn  test_split(){
    let v = [10,1, 2, 3, 4, 5, 6];
    let (left, right) = v.split_array_ref::<3>();
    let (left, right) = v.split_at(3);
    println!("{:?}被切割后， left={:?},right={:?}",v,left,right); // [1]
}

/**
 * 测试排序
 */

fn test_sort(){
   
}

/**
 * 测试反转
 */
fn test_reverse(){

}

/**
 * 测试基本的聚合操作，比如求和、最大值等
 */
fn test_agg(){

}